
    var AuthCipher = __webpack_require__("KD+Z")
    var Buffer = __webpack_require__("38Wu").Buffer
    var MODES = __webpack_require__("zdSg")
    var StreamCipher = __webpack_require__("XmsB")
    var Transform = __webpack_require__("bjfr")
    var aes = __webpack_require__("dNn4")
    var ebtk = __webpack_require__("exU6")
    var inherits = __webpack_require__("4Bm0")
    
    function Decipher (mode, key, iv) {
      Transform.call(this)
    
      this._cache = new Splitter()
      this._last = void 0
      this._cipher = new aes.AES(key)
      this._prev = Buffer.from(iv)
      this._mode = mode
      this._autopadding = true
    }
    
    inherits(Decipher, Transform)
    
    Decipher.prototype._update = function (data) {
      this._cache.add(data)
      var chunk
      var thing
      var out = []
      while ((chunk = this._cache.get(this._autopadding))) {
        thing = this._mode.decrypt(this, chunk)
        out.push(thing)
      }
      return Buffer.concat(out)
    }
    
    Decipher.prototype._final = function () {
      var chunk = this._cache.flush()
      if (this._autopadding) {
        return unpad(this._mode.decrypt(this, chunk))
      } else if (chunk) {
        throw new Error('data not multiple of block length')
      }
    }
    
    Decipher.prototype.setAutoPadding = function (setTo) {
      this._autopadding = !!setTo
      return this
    }
    
    function Splitter () {
      this.cache = Buffer.allocUnsafe(0)
    }
    
    Splitter.prototype.add = function (data) {
      this.cache = Buffer.concat([this.cache, data])
    }
    
    Splitter.prototype.get = function (autoPadding) {
      var out
      if (autoPadding) {
        if (this.cache.length > 16) {
          out = this.cache.slice(0, 16)
          this.cache = this.cache.slice(16)
          return out
        }
      } else {
        if (this.cache.length >= 16) {
          out = this.cache.slice(0, 16)
          this.cache = this.cache.slice(16)
          return out
        }
      }
    
      return null
    }
    
    Splitter.prototype.flush = function () {
      if (this.cache.length) return this.cache
    }
    
    function unpad (last) {
      var padded = last[15]
      if (padded < 1 || padded > 16) {
        throw new Error('unable to decrypt data')
      }
      var i = -1
      while (++i < padded) {
        if (last[(i + (16 - padded))] !== padded) {
          throw new Error('unable to decrypt data')
        }
      }
      if (padded === 16) return
    
      return last.slice(0, 16 - padded)
    }
    
    function createDecipheriv (suite, password, iv) {
      var config = MODES[suite.toLowerCase()]
      if (!config) throw new TypeError('invalid suite type')
    
      if (typeof iv === 'string') iv = Buffer.from(iv)
      if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)
    
      if (typeof password === 'string') password = Buffer.from(password)
      if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)
    
      if (config.type === 'stream') {
        return new StreamCipher(config.module, password, iv, true)
      } else if (config.type === 'auth') {
        return new AuthCipher(config.module, password, iv, true)
      }
    
      return new Decipher(config.module, password, iv)
    }
    
    function createDecipher (suite, password) {
      var config = MODES[suite.toLowerCase()]
      if (!config) throw new TypeError('invalid suite type')
    
      var keys = ebtk(password, false, config.key, config.iv)
      return createDecipheriv(suite, keys.key, keys.iv)
    }

    export {
        createDecipher,
        createDecipheriv
    }